package sse

import (
	"context"

	"github.com/google/uuid"
)

// ChatResponseInterceptor 聊天响应拦截器接口
type ChatResponseInterceptor interface {
	// Intercept 拦截并可能修改聊天响应
	// 返回 nil 表示过滤掉该消息（不发送给前端）
	// 返回修改后的事件
	Intercept(ctx context.Context, event *StreamEvent) *StreamEvent
}

// InterceptorChain 拦截器链
type InterceptorChain struct {
	interceptors []ChatResponseInterceptor
}

// NewInterceptorChain 创建拦截器链
func NewInterceptorChain(interceptors ...ChatResponseInterceptor) *InterceptorChain {
	return &InterceptorChain{
		interceptors: interceptors,
	}
}

// Process 处理事件，依次通过所有拦截器
func (c *InterceptorChain) Process(ctx context.Context, event *StreamEvent) *StreamEvent {
	current := event
	for _, interceptor := range c.interceptors {
		if current == nil {
			break
		}
		current = interceptor.Intercept(ctx, current)
	}
	return current
}

// ChatResponseConverter 将agent的ChatResponse转换为StreamEvent
type ChatResponseConverter struct {
	interceptorChain *InterceptorChain
}

// NewChatResponseConverter 创建转换器
func NewChatResponseConverter(interceptors ...ChatResponseInterceptor) *ChatResponseConverter {
	return &ChatResponseConverter{
		interceptorChain: NewInterceptorChain(interceptors...),
	}
}

// Convert 转换ChatResponse为StreamEvent
func (c *ChatResponseConverter) Convert(ctx context.Context, chatResp *ChatResponse) *StreamEvent {
	// 1. 转换为StreamEvent
	event := c.convertToStreamEvent(chatResp)

	// 2. 通过拦截器链处理
	return c.interceptorChain.Process(ctx, event)
}

// convertToStreamEvent 内部转换方法
func (c *ChatResponseConverter) convertToStreamEvent(chatResp *ChatResponse) *StreamEvent {
	// 转换状态
	status := c.convertStatus(chatResp.Status)

	event := NewChatEvent(chatResp.ConversationID, status)

	// 设置内容
	if chatResp.Content != "" {
		event.WithContent(chatResp.Content)
	}
	if chatResp.DeltaContent != "" {
		event.WithDeltaContent(chatResp.DeltaContent)
	}
	if chatResp.ReasoningContent != "" {
		event.WithReasoningContent(chatResp.ReasoningContent)
	}
	if chatResp.DeltaReasoningContent != "" {
		event.WithDeltaReasoningContent(chatResp.DeltaReasoningContent)
	}
	if chatResp.StatusMessage != "" {
		event.WithStatusMessage(chatResp.StatusMessage)
	}

	// 设置错误信息
	if chatResp.Error != nil {
		event.WithError(
			chatResp.Error.Code,
			chatResp.Error.Message,
			chatResp.Error.Details,
			chatResp.Error.Retry,
		)
	}

	return event
}

// convertStatus 转换状态枚举
func (c *ChatResponseConverter) convertStatus(status ResponseStatus) ChatStatus {
	// 现在ChatStatus和ResponseStatus是同一个类型，直接返回
	return status
}

// DefaultInterceptor 默认拦截器（原样传递）
type DefaultInterceptor struct{}

// Intercept 实现ChatResponseInterceptor接口
func (d *DefaultInterceptor) Intercept(ctx context.Context, event *StreamEvent) *StreamEvent {
	// 目前原样传递，未来可以在这里添加：
	// - 内容审核
	// - 敏感信息过滤
	// - 消息格式化
	// - 用户权限检查
	// - 日志记录
	return event
}

// ContentFilterInterceptor 内容过滤拦截器示例
type ContentFilterInterceptor struct {
	// 可以配置敏感词列表、过滤规则等
}

// Intercept 实现内容过滤
func (f *ContentFilterInterceptor) Intercept(ctx context.Context, event *StreamEvent) *StreamEvent {
	// 示例：未来可以实现
	// - 敏感词替换
	// - 内容长度限制
	// - 格式验证
	// 目前原样返回
	return event
}

// DebugInterceptor 调试拦截器示例
type DebugInterceptor struct {
	conversationID uuid.UUID
}

// NewDebugInterceptor 创建调试拦截器
func NewDebugInterceptor(conversationID uuid.UUID) *DebugInterceptor {
	return &DebugInterceptor{
		conversationID: conversationID,
	}
}

// Intercept 实现调试日志
func (d *DebugInterceptor) Intercept(ctx context.Context, event *StreamEvent) *StreamEvent {
	// 示例：未来可以实现
	// - 详细的消息日志
	// - 性能监控
	// - 错误追踪
	// 目前原样返回
	return event
}
